package com.stu.interview;

import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigDecimal;

/**
 * Java 基础面试题代码演示
 * 涵盖面向对象编程特征、基本数据类型、运算符、关键字等核心概念
 * 
 * @author Study
 * @version 1.0
 */
public class JavaBasicsDemo {
    
    // 静态变量演示
    private static int staticVar = 100;
    
    // 实例变量演示
    private int instanceVar = 200;
    
    // final 变量演示
    private final String FINAL_VAR = "不可变";
    
    public static void main(String[] args) {
        System.out.println("=== Java 基础面试题代码演示 ===");
        
        JavaBasicsDemo demo = new JavaBasicsDemo();
        
        // 1. 面向对象编程特征演示
        demo.demonstrateOOP();
        
        // 2. JDK与JRE区别说明
        demo.explainJDKvsJRE();
        
        // 3. 基本数据类型演示
        demo.demonstrateDataTypes();
        
        // 4. == 和 equals 比较演示
        demo.demonstrateEqualsComparison();
        
        // 5. 访问修饰符演示
        demo.demonstrateAccessModifiers();
        
        // 6. this 和 super 演示
        demo.demonstrateThisAndSuper();
        
        // 7. 类型转换和运算符演示
        demo.demonstrateTypeConversion();
        
        // 8. 循环和跳转演示
        demo.demonstrateLoopsAndJumps();
        
        // 9. static 关键字演示
        demo.demonstrateStaticKeyword();
        
        // 10. final 关键字演示
        demo.demonstrateFinalKeyword();
        
        // 11. 重载和重写演示
        demo.demonstrateOverloadAndOverride();
        
        // 12. 异常处理演示
        demo.demonstrateExceptionHandling();
        
        // 13. 包装类型和自动装箱演示
        demo.demonstrateWrapperTypes();
        
        // 14. String 相关演示
        demo.demonstrateStringOperations();
        
        // 15. Object 类方法演示
        demo.demonstrateObjectMethods();
        
        // 16. 反射机制演示
        demo.demonstrateReflection();
        
        // 17. Java 8 新特性演示
        demo.demonstrateJava8Features();
        
        // 18. 数学运算和类型转换演示
        demo.demonstrateMathAndConversion();
        
        // 19. 接口和抽象类演示
        demo.demonstrateInterfaceAndAbstract();
        
        // 20. 内部类演示
        demo.demonstrateInnerClass();
        
        // 21. 泛型演示
        demo.demonstrateGenerics();
        
        // 22. 枚举演示
        demo.demonstrateEnum();
        
        // 23. 注解演示
        demo.demonstrateAnnotation();
        
        System.out.println("\n\n=== Java 基础面试题演示完成 ===");
        System.out.println("本演示涵盖了 Java 基础的主要知识点，包括:");
        System.out.println("- 面向对象编程 (封装、继承、多态、抽象)");
        System.out.println("- 数据类型和运算符");
        System.out.println("- 异常处理机制");
        System.out.println("- String 和包装类");
        System.out.println("- 反射机制");
        System.out.println("- Java 8 新特性");
        System.out.println("- 接口和抽象类");
        System.out.println("- 内部类");
        System.out.println("- 泛型");
        System.out.println("- 枚举");
        System.out.println("- 注解");
        System.out.println("这些都是 Java 面试中的高频考点！");
    }
    
    /**
     * 1. 面向对象编程特征演示
     * 封装、继承、多态、抽象
     */
    private void demonstrateOOP() {
        System.out.println("\n=== 1. 面向对象编程特征 ===");
        
        // 封装：通过private修饰符隐藏内部实现
        Animal animal = new Dog("旺财", 3);
        System.out.println("封装演示 - 动物名称: " + animal.getName());
        
        // 继承：Dog继承Animal
        Dog dog = new Dog("小黑", 2);
        dog.eat(); // 继承父类方法
        dog.bark(); // 子类特有方法
        
        // 多态：同一接口不同实现
        Animal[] animals = {new Dog("狗狗", 1), new Cat("猫咪", 2)};
        for (Animal a : animals) {
            a.makeSound(); // 多态调用
        }
        
        // 抽象：抽象类和接口
        Flyable bird = new Bird();
        bird.fly();
    }
    
    /**
     * 2. JDK与JRE区别说明
     */
    private void explainJDKvsJRE() {
        System.out.println("\n=== 2. JDK与JRE区别 ===");
        System.out.println("JDK (Java Development Kit):");
        System.out.println("- 包含JRE + 开发工具(javac, jar, javadoc等)");
        System.out.println("- 用于Java程序开发");
        System.out.println("\nJRE (Java Runtime Environment):");
        System.out.println("- 包含JVM + Java核心类库");
        System.out.println("- 用于运行Java程序");
        System.out.println("\n当前Java版本: " + System.getProperty("java.version"));
        System.out.println("Java运行时路径: " + System.getProperty("java.home"));
    }
    
    /**
     * 3. Java基本数据类型演示
     */
    private void demonstrateDataTypes() {
        System.out.println("\n=== 3. Java基本数据类型 ===");
        
        // 8种基本数据类型
        byte byteVar = 127; // -128 ~ 127 (1字节)
        short shortVar = 32767; // -32768 ~ 32767 (2字节)
        int intVar = 2147483647; // -2^31 ~ 2^31-1 (4字节)
        long longVar = 9223372036854775807L; // -2^63 ~ 2^63-1 (8字节)
        
        float floatVar = 3.14f; // 单精度浮点数 (4字节)
        double doubleVar = 3.141592653589793; // 双精度浮点数 (8字节)
        
        char charVar = '中'; // Unicode字符 (2字节)
        boolean boolVar = true; // true/false (1位)
        
        System.out.println("byte范围: " + Byte.MIN_VALUE + " ~ " + Byte.MAX_VALUE);
        System.out.println("short范围: " + Short.MIN_VALUE + " ~ " + Short.MAX_VALUE);
        System.out.println("int范围: " + Integer.MIN_VALUE + " ~ " + Integer.MAX_VALUE);
        System.out.println("long范围: " + Long.MIN_VALUE + " ~ " + Long.MAX_VALUE);
        System.out.println("float范围: " + Float.MIN_VALUE + " ~ " + Float.MAX_VALUE);
        System.out.println("double范围: " + Double.MIN_VALUE + " ~ " + Double.MAX_VALUE);
        System.out.println("char可以存储中文: " + charVar);
        System.out.println("boolean值: " + boolVar);
        
        // byte取值范围为什么是-128~127
        System.out.println("\nbyte为什么是-128~127?");
        System.out.println("byte占1字节=8位，可表示2^8=256个数");
        System.out.println("使用补码表示：0~127为正数，-128~-1为负数");
    }
    
    /**
     * 4. == 和 equals 比较演示
     */
    private void demonstrateEqualsComparison() {
        System.out.println("\n=== 4. == 和 equals 比较 ===");
        
        // 基本数据类型比较
        int a = 100;
        int b = 100;
        System.out.println("基本类型 == 比较: " + (a == b)); // true，比较值
        
        // 包装类型比较
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
        
        System.out.println("Integer缓存范围内 == : " + (i1 == i2)); // true，缓存
        System.out.println("Integer缓存范围外 == : " + (i3 == i4)); // false，不同对象
        System.out.println("Integer equals比较: " + i3.equals(i4)); // true，比较值
        
        // String比较
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        
        System.out.println("String字面量 == : " + (s1 == s2)); // true，字符串池
        System.out.println("String对象 == : " + (s1 == s3)); // false，不同对象
        System.out.println("String equals: " + s1.equals(s3)); // true，比较内容
        
        // 自定义对象比较
        Person p1 = new Person("张三", 25);
        Person p2 = new Person("张三", 25);
        System.out.println("自定义对象 == : " + (p1 == p2)); // false
        System.out.println("自定义对象 equals: " + p1.equals(p2)); // true，重写了equals
    }
    
    /**
     * 5. 访问修饰符演示
     */
    private void demonstrateAccessModifiers() {
        System.out.println("\n=== 5. 访问修饰符 ===");
        System.out.println("public: 所有类都可访问");
        System.out.println("protected: 同包或子类可访问");
        System.out.println("默认(package): 同包内可访问");
        System.out.println("private: 仅本类内可访问");
        
        AccessModifierDemo demo = new AccessModifierDemo();
        demo.showAccessibility();
    }
    
    /**
     * 6. this 和 super 演示
     */
    private void demonstrateThisAndSuper() {
        System.out.println("\n=== 6. this 和 super 演示 ===");
        
        Child child = new Child("子类");
        child.showDifference();
    }
    
    /**
     * 7. 类型转换和运算符演示
     */
    private void demonstrateTypeConversion() {
        System.out.println("\n=== 7. 类型转换和运算符演示 ===");
        
        // short类型运算
        short s1 = 1;
        s1 += 1; // 正确，+=会自动强制转换
        System.out.println("s1 += 1 结果: " + s1);
        
        // s1 = s1 + 1; // 编译错误，需要强制转换
        s1 = (short)(s1 + 1); // 正确
        System.out.println("s1 = (short)(s1 + 1) 结果: " + s1);
        
        // float赋值
        // float n = 1.8; // 编译错误，1.8默认是double
        float n = 1.8f; // 正确
        System.out.println("float n = 1.8f: " + n);
        
        // i++和++i的区别
        int i = 5;
        System.out.println("i++: " + (i++)); // 先使用后自增，输出5
        System.out.println("当前i: " + i); // 6
        
        i = 5;
        System.out.println("++i: " + (++i)); // 先自增后使用，输出6
        
        // &和&&的区别
        boolean result1 = true & false; // 位运算，都会执行
        boolean result2 = true && false; // 逻辑运算，短路
        System.out.println("& 结果: " + result1);
        System.out.println("&& 结果: " + result2);
        
        // 位运算优化乘法
        int multiply = 2 * 8;
        int bitShift = 2 << 3; // 左移3位等于乘以2^3=8
        System.out.println("2 * 8 = " + multiply);
        System.out.println("2 << 3 = " + bitShift);
        System.out.println("位运算更高效: " + (multiply == bitShift));
    }
    
    /**
     * 8. 循环和跳转演示
     */
    private void demonstrateLoopsAndJumps() {
        System.out.println("\n=== 8. 循环和跳转演示 ===");
        
        // while和do-while区别
        System.out.println("while循环:");
        int i = 0;
        while (i < 3) {
            System.out.print(i + " ");
            i++;
        }
        
        System.out.println("\ndo-while循环:");
        i = 0;
        do {
            System.out.print(i + " ");
            i++;
        } while (i < 3);
        
        // 跳出多层循环
        System.out.println("\n\n跳出多层循环演示:");
        outer: for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 3; k++) {
                if (j == 1 && k == 1) {
                    System.out.println("跳出外层循环");
                    break outer;
                }
                System.out.println("j=" + j + ", k=" + k);
            }
        }
    }
    
    /**
     * 9. static关键字演示
     */
    private void demonstrateStaticKeyword() {
        System.out.println("\n=== 9. static关键字演示 ===");
        
        System.out.println("静态变量: " + staticVar);
        System.out.println("实例变量: " + instanceVar);
        
        // 静态方法调用
        StaticDemo.staticMethod();
        
        // static不能修饰局部变量
        // static int localVar = 10; // 编译错误
        
        System.out.println("static特点:");
        System.out.println("1. 属于类，不属于实例");
        System.out.println("2. 类加载时初始化");
        System.out.println("3. 所有实例共享");
        System.out.println("4. 可以通过类名直接访问");
    }
    
    /**
     * 10. final关键字演示
     */
    private void demonstrateFinalKeyword() {
        System.out.println("\n=== 10. final关键字演示 ===");
        
        System.out.println("final变量: " + FINAL_VAR);
        
        // final变量不能重新赋值
        // FINAL_VAR = "尝试修改"; // 编译错误
        
        final int finalLocal = 100;
        // finalLocal = 200; // 编译错误
        
        System.out.println("final用法:");
        System.out.println("1. final变量：常量，不可修改");
        System.out.println("2. final方法：不可重写");
        System.out.println("3. final类：不可继承(如String)");
        
        // final、finally、finalize区别
        System.out.println("\nfinal vs finally vs finalize:");
        System.out.println("final: 关键字，表示不可变");
        System.out.println("finally: 异常处理块，总是执行");
        System.out.println("finalize: Object方法，GC前调用");
    }
    
    /**
     * 11. 重载和重写演示
     */
    private void demonstrateOverloadAndOverride() {
        System.out.println("\n=== 11. 重载和重写演示 ===");
        
        OverloadDemo demo = new OverloadDemo();
        
        // 方法重载
        System.out.println("重载演示:");
        demo.print("字符串");
        demo.print(123);
        demo.print("字符串", 456);
        
        // 方法重写
        System.out.println("\n重写演示:");
        Animal animal = new Dog("重写狗", 1);
        animal.makeSound(); // 调用重写后的方法
        
        System.out.println("\n重载 vs 重写:");
        System.out.println("重载(Overload): 同类中方法名相同，参数不同");
        System.out.println("重写(Override): 子类重新实现父类方法");
    }
    
    /**
     * 12. 异常处理演示
     */
    private void demonstrateExceptionHandling() {
        System.out.println("\n=== 12. 异常处理演示 ===");
        
        // try-catch-finally
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("捕获算术异常: " + e.getMessage());
        } finally {
            System.out.println("finally块总是执行");
        }
        
        // 异常分类
        System.out.println("\n异常分类:");
        System.out.println("Error: 系统级错误，如OutOfMemoryError");
        System.out.println("Exception: 程序异常");
        System.out.println("  - RuntimeException: 运行时异常(非受检)");
        System.out.println("  - 其他Exception: 受检异常");
        
        // 常见运行时异常
        demonstrateCommonExceptions();
    }
    
    /**
     * 常见异常演示
     */
    private void demonstrateCommonExceptions() {
        System.out.println("\n常见运行时异常:");
        
        try {
            // NullPointerException
            String str = null;
            // str.length(); // 会抛出NPE
            System.out.println("NullPointerException: 空指针异常");
        } catch (Exception e) {
            System.out.println("捕获异常: " + e.getClass().getSimpleName());
        }
        
        try {
            // ArrayIndexOutOfBoundsException
            int[] arr = {1, 2, 3};
            // int value = arr[5]; // 会抛出数组越界
            System.out.println("ArrayIndexOutOfBoundsException: 数组越界");
        } catch (Exception e) {
            System.out.println("捕获异常: " + e.getClass().getSimpleName());
        }
        
        System.out.println("ClassCastException: 类型转换异常");
        System.out.println("NumberFormatException: 数字格式异常");
        System.out.println("IllegalArgumentException: 非法参数异常");
    }
    
    /**
     * 13. 包装类型和自动装箱演示
     */
    private void demonstrateWrapperTypes() {
        System.out.println("\n=== 13. 包装类型和自动装箱演示 ===");
        
        // 基本类型 vs 包装类型
        int primitive = 100;
        Integer wrapper = 100; // 自动装箱
        
        System.out.println("基本类型: " + primitive);
        System.out.println("包装类型: " + wrapper);
        
        // 自动装箱和拆箱
        Integer autoBox = primitive; // 自动装箱
        int autoUnbox = wrapper; // 自动拆箱
        
        System.out.println("自动装箱: " + autoBox);
        System.out.println("自动拆箱: " + autoUnbox);
        
        // 包装类型缓存
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 128;
        Integer i4 = 128;
        
        System.out.println("缓存范围内(-128~127): " + (i1 == i2)); // true
        System.out.println("缓存范围外: " + (i3 == i4)); // false
        
        // void vs Void
        System.out.println("\nvoid vs Void:");
        System.out.println("void: 关键字，表示无返回值");
        System.out.println("Void: 包装类，用于泛型等场景");
    }
    
    /**
     * 14. String相关演示
     */
    private void demonstrateStringOperations() {
        System.out.println("\n=== 14. String相关演示 ===");
        
        // String特性
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");
        
        System.out.println("String是基本类型吗? " + false);
        System.out.println("String可以被继承吗? " + false + " (final类)");
        System.out.println("String是不可变的吗? " + true);
        
        // 字符串拼接
        System.out.println("\n字符串拼接性能:");
        long start = System.currentTimeMillis();
        String result = "";
        for (int i = 0; i < 1000; i++) {
            result += "a"; // 效率低
        }
        long end = System.currentTimeMillis();
        System.out.println("String + 耗时: " + (end - start) + "ms");
        
        start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            sb.append("a"); // 效率高
        }
        end = System.currentTimeMillis();
        System.out.println("StringBuilder 耗时: " + (end - start) + "ms");
        
        // StringBuffer vs StringBuilder
        System.out.println("\nStringBuffer vs StringBuilder:");
        System.out.println("StringBuffer: 线程安全，同步方法");
        System.out.println("StringBuilder: 线程不安全，性能更好");
        
        // 字符串反转
        String original = "Hello World";
        String reversed = new StringBuilder(original).reverse().toString();
        System.out.println("原字符串: " + original);
        System.out.println("反转后: " + reversed);
        
        // 数组length vs String length()
        int[] array = {1, 2, 3};
        System.out.println("\n数组length属性: " + array.length);
        System.out.println("String length()方法: " + str1.length());
    }
    
    /**
     * 15. Object类方法演示
     */
    private void demonstrateObjectMethods() {
        System.out.println("\n=== 15. Object类方法演示 ===");
        
        Person person = new Person("张三", 25);
        
        System.out.println("toString(): " + person.toString());
        System.out.println("hashCode(): " + person.hashCode());
        System.out.println("getClass(): " + person.getClass().getName());
        
        Person person2 = new Person("张三", 25);
        System.out.println("equals(): " + person.equals(person2));
        
        System.out.println("\nObject类常用方法:");
        System.out.println("toString(): 对象字符串表示");
        System.out.println("equals(): 对象相等性比较");
        System.out.println("hashCode(): 对象哈希码");
        System.out.println("getClass(): 获取Class对象");
        System.out.println("clone(): 对象克隆");
        System.out.println("finalize(): GC前调用");
        System.out.println("wait()/notify(): 线程通信");
        
        // 16. 反射机制演示
        demonstrateReflection();
        
        // 17. Java 8 新特性演示
        demonstrateJava8Features();
        
        // 18. 数学运算和类型转换演示
         demonstrateMathAndConversion();
         
         // 19. 接口和抽象类演示
         demonstrateInterfaceAndAbstract();
         
         // 20. 内部类演示
         demonstrateInnerClass();
         
         // 21. 泛型演示
         demonstrateGenerics();
         
         // 22. 枚举演示
         demonstrateEnum();
         
         // 23. 注解演示
         demonstrateAnnotation();
     }
    
    /**
     * 16. 反射机制演示
     */
    private void demonstrateReflection() {
        System.out.println("\n=== 16. 反射机制演示 ===");
        
        try {
            // 获取 Class 对象的三种方式
            System.out.println("获取 Class 对象的方式:");
            Class<?> clazz1 = String.class; // 方式1：类名.class
            Class<?> clazz2 = "Hello".getClass(); // 方式2：对象.getClass()
            Class<?> clazz3 = Class.forName("java.lang.String"); // 方式3：Class.forName()
            
            System.out.println("方式1 - 类名.class: " + clazz1.getName());
            System.out.println("方式2 - 对象.getClass(): " + clazz2.getName());
            System.out.println("方式3 - Class.forName(): " + clazz3.getName());
            System.out.println("三种方式获取的是同一个 Class 对象: " + (clazz1 == clazz2 && clazz2 == clazz3));
            
            // 反射访问私有字段
            System.out.println("\n反射访问私有字段:");
            ReflectionDemo demo = new ReflectionDemo("私有字段值");
            Class<?> demoClass = demo.getClass();
            Field privateField = demoClass.getDeclaredField("privateField");
            privateField.setAccessible(true); // 设置可访问
            String fieldValue = (String) privateField.get(demo);
            System.out.println("私有字段值: " + fieldValue);
            
            privateField.set(demo, "修改后的值");
            System.out.println("修改后的私有字段值: " + privateField.get(demo));
            
        } catch (Exception e) {
            System.out.println("反射操作异常: " + e.getMessage());
        }
        
        System.out.println("\n反射的优缺点:");
        System.out.println("优点:");
        System.out.println("1. 运行时动态获取类信息");
        System.out.println("2. 动态创建对象和调用方法");
        System.out.println("3. 框架开发的基础 (Spring、Hibernate 等)");
        System.out.println("4. 突破访问权限限制");
        
        System.out.println("\n缺点:");
        System.out.println("1. 性能开销较大");
        System.out.println("2. 破坏封装性");
        System.out.println("3. 代码可读性差");
        System.out.println("4. 编译时无法检查错误");
    }
    
    /**
     * 17. Java 8 新特性演示
     */
    private void demonstrateJava8Features() {
        System.out.println("\n=== 17. Java 8 新特性演示 ===");
        
        // Lambda 表达式
        System.out.println("1. Lambda 表达式:");
        java.util.List<String> names = Arrays.asList("张三", "李四", "王五", "赵六");
        
        // 传统方式
        System.out.println("传统方式遍历:");
        for (String name : names) {
            System.out.print(name + " ");
        }
        System.out.println();
        
        // Lambda 表达式
        System.out.println("Lambda 表达式遍历:");
        names.forEach(name -> System.out.print(name + " "));
        System.out.println();
        
        // Stream API
        System.out.println("\n2. Stream API:");
        java.util.List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // 过滤偶数并求和
        int evenSum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();
        System.out.println("偶数之和: " + evenSum);
        
        // Optional 类
        System.out.println("\n3. Optional 类:");
        Optional<String> optional = Optional.of("Hello Optional");
        System.out.println("Optional 值存在: " + optional.isPresent());
        System.out.println("Optional 值: " + optional.get());
        
        Optional<String> emptyOptional = Optional.empty();
        String defaultValue = emptyOptional.orElse("默认值");
        System.out.println("空 Optional 的默认值: " + defaultValue);
        
        System.out.println("\nJava 8 新特性总结:");
        System.out.println("1. Lambda 表达式 - 函数式编程");
        System.out.println("2. Stream API - 流式处理");
        System.out.println("3. 方法引用 - 简化 Lambda");
        System.out.println("4. Optional 类 - 避免空指针");
        System.out.println("5. 接口默认方法 - 接口演进");
        System.out.println("6. 新的日期时间 API - 线程安全");
    }
    
    /**
     * 18. 数学运算和类型转换演示
     */
    private void demonstrateMathAndConversion() {
        System.out.println("\n=== 18. 数学运算和类型转换演示 ===");
        
        // Math.round 方法
        System.out.println("Math.round 方法:");
        System.out.println("Math.round(1.5) = " + Math.round(1.5)); // 2
        System.out.println("Math.round(-1.5) = " + Math.round(-1.5)); // -1
        System.out.println("Math.round(1.4) = " + Math.round(1.4)); // 1
        System.out.println("Math.round(-1.4) = " + Math.round(-1.4)); // -1
        System.out.println("Math.round(1.6) = " + Math.round(1.6)); // 2
        System.out.println("Math.round(-1.6) = " + Math.round(-1.6)); // -2
        
        System.out.println("\nMath.round 规则: 加 0.5 后向下取整");
        System.out.println("1.5 + 0.5 = 2.0 -> 2");
        System.out.println("-1.5 + 0.5 = -1.0 -> -1");
        
        // 浮点数精度问题
        System.out.println("\n浮点数精度问题:");
        System.out.println("0.1 + 0.2 = " + (0.1 + 0.2));
        System.out.println("0.1 + 0.2 == 0.3: " + (0.1 + 0.2 == 0.3));
        
        // 使用 BigDecimal 解决精度问题
        java.math.BigDecimal bd1 = new java.math.BigDecimal("0.1");
        java.math.BigDecimal bd2 = new java.math.BigDecimal("0.2");
        java.math.BigDecimal bd3 = bd1.add(bd2);
         System.out.println("BigDecimal 0.1 + 0.2 = " + bd3);
     }

    /**
     * 演示接口和抽象类的区别
     * 面试题：接口和抽象类有什么区别？
     */
    private static void demonstrateInterfaceAndAbstract() {
        System.out.println("\n19. === 接口和抽象类演示 ===");
        
        // 抽象类使用
        System.out.println("抽象类使用:");
        Animal dog = new Dog("旺财", 3);
        dog.eat(); // 抽象方法实现
        dog.sleep(); // 具体方法
        dog.makeSound(); // 抽象方法实现
        
        Animal cat = new Cat("咪咪", 2);
        cat.eat();
        cat.sleep();
        cat.makeSound();
        
        // 接口使用
        System.out.println("\n接口使用:");
        Flyable bird = new Bird();
        bird.fly();
        
        Swimmable fish = new Fish();
        fish.swim();
        
        // 多接口实现
        Duck duck = new Duck();
        duck.fly(); // Flyable 接口
        duck.swim(); // Swimmable 接口
        duck.walk(); // 自己的方法
        
        System.out.println("\n接口和抽象类的区别:");
        System.out.println("抽象类:");
        System.out.println("1. 可以有构造方法");
        System.out.println("2. 可以有实例变量");
        System.out.println("3. 可以有具体方法和抽象方法");
        System.out.println("4. 单继承");
        System.out.println("5. 访问修饰符无限制");
        
        System.out.println("\n接口:");
        System.out.println("1. 不能有构造方法");
        System.out.println("2. 只能有常量 (public static final)");
        System.out.println("3. 只能有抽象方法和默认方法 (Java 8+)");
        System.out.println("4. 多实现");
        System.out.println("5. 方法默认 public abstract");
    }

    /**
     * 演示内部类
     * 面试题：Java 内部类有哪几种？各有什么特点？
     */
    private static void demonstrateInnerClass() {
        System.out.println("\n20. === 内部类演示 ===");
        
        // 成员内部类
        System.out.println("1. 成员内部类:");
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.innerMethod();
        
        // 静态内部类
        System.out.println("\n2. 静态内部类:");
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.staticInnerMethod();
        
        // 局部内部类
        System.out.println("\n3. 局部内部类:");
        outer.methodWithLocalClass();
        
        // 匿名内部类
        System.out.println("\n4. 匿名内部类:");
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现 Runnable 接口");
            }
        };
        runnable.run();
        
        // Lambda 表达式 (Java 8+)
        System.out.println("\n5. Lambda 表达式 (替代匿名内部类):");
        Runnable lambdaRunnable = () -> System.out.println("Lambda 表达式实现 Runnable 接口");
        lambdaRunnable.run();
        
        System.out.println("\n内部类总结:");
        System.out.println("1. 成员内部类 - 可访问外部类所有成员");
        System.out.println("2. 静态内部类 - 只能访问外部类静态成员");
        System.out.println("3. 局部内部类 - 定义在方法中，可访问 final 局部变量");
        System.out.println("4. 匿名内部类 - 没有类名，常用于接口实现");
    }

    /**
     * 演示泛型
     * 面试题：Java 泛型有什么用？什么是类型擦除？
     */
    private static void demonstrateGenerics() {
        System.out.println("\n21. === 泛型演示 ===");
        
        // 泛型类使用
        System.out.println("1. 泛型类使用:");
        GenericClass<String> stringGeneric = new GenericClass<>("Hello Generics");
        System.out.println("String 泛型: " + stringGeneric.getValue());
        
        GenericClass<Integer> integerGeneric = new GenericClass<>(123);
        System.out.println("Integer 泛型: " + integerGeneric.getValue());
        
        // 泛型方法使用
        System.out.println("\n2. 泛型方法使用:");
        String[] stringArray = {"A", "B", "C"};
        Integer[] intArray = {1, 2, 3};
        
        System.out.println("交换前 String 数组: " + Arrays.toString(stringArray));
        GenericMethods.swap(stringArray, 0, 2);
        System.out.println("交换后 String 数组: " + Arrays.toString(stringArray));
        
        System.out.println("交换前 Integer 数组: " + Arrays.toString(intArray));
        GenericMethods.swap(intArray, 0, 2);
        System.out.println("交换后 Integer 数组: " + Arrays.toString(intArray));
        
        // 通配符使用
        System.out.println("\n3. 通配符使用:");
        List<String> stringList = Arrays.asList("Hello", "World");
        List<Integer> intList = Arrays.asList(1, 2, 3);
        
        GenericMethods.printList(stringList); // ? extends Object
        GenericMethods.printList(intList);
        
        List<Number> numberList = new ArrayList<>();
        GenericMethods.addNumbers(numberList); // ? super Integer
        System.out.println("添加数字后的列表: " + numberList);
        
        // 类型擦除演示
        System.out.println("\n4. 类型擦除演示:");
        List<String> stringListForErasure = new ArrayList<>();
        List<Integer> intListForErasure = new ArrayList<>();
        
        System.out.println("String List 类型: " + stringListForErasure.getClass());
        System.out.println("Integer List 类型: " + intListForErasure.getClass());
        System.out.println("两个 List 类型相同: " + 
            (stringListForErasure.getClass() == intListForErasure.getClass()));
        
        System.out.println("\n泛型的优点:");
        System.out.println("1. 类型安全 - 编译时检查类型");
        System.out.println("2. 消除强制类型转换");
        System.out.println("3. 提高代码复用性");
        System.out.println("4. 提高性能 - 避免装箱拆箱");
        
        System.out.println("\n类型擦除:");
        System.out.println("1. 编译时泛型信息被擦除");
        System.out.println("2. 运行时只保留原始类型");
        System.out.println("3. 保证与旧版本 Java 兼容");
    }

    /**
     * 演示枚举
     * 面试题：Java 枚举有什么特点？枚举可以继承吗？
     */
    private static void demonstrateEnum() {
        System.out.println("\n22. === 枚举演示 ===");
        
        // 简单枚举使用
        System.out.println("1. 简单枚举使用:");
        for (Color color : Color.values()) {
            System.out.println("颜色: " + color + ", 序号: " + color.ordinal());
        }
        
        // 带属性的枚举
        System.out.println("\n2. 带属性的枚举:");
        for (Planet planet : Planet.values()) {
            System.out.printf("行星: %s, 质量: %.2e kg, 半径: %.2e m%n", 
                planet, planet.getMass(), planet.getRadius());
        }
        
        // 枚举方法使用
        System.out.println("\n3. 枚举方法使用:");
        Planet earth = Planet.EARTH;
        System.out.println("地球表面重力: " + earth.surfaceGravity() + " m/s²");
        System.out.println("70kg 人在地球重量: " + earth.surfaceWeight(70) + " N");
        
        Planet mars = Planet.MARS;
        System.out.println("火星表面重力: " + mars.surfaceGravity() + " m/s²");
        System.out.println("70kg 人在火星重量: " + mars.surfaceWeight(70) + " N");
        
        // 枚举比较
        System.out.println("\n4. 枚举比较:");
        Color red1 = Color.RED;
        Color red2 = Color.RED;
        System.out.println("枚举 == 比较: " + (red1 == red2));
        System.out.println("枚举 equals 比较: " + red1.equals(red2));
        
        // 枚举在 switch 中使用
        System.out.println("\n5. 枚举在 switch 中使用:");
        processColor(Color.RED);
        processColor(Color.GREEN);
        processColor(Color.BLUE);
        
        System.out.println("\n枚举特点:");
        System.out.println("1. 类型安全的常量");
        System.out.println("2. 不能被继承，但可以实现接口");
        System.out.println("3. 默认继承 java.lang.Enum");
        System.out.println("4. 可以有构造方法、字段和方法");
        System.out.println("5. 实例在类加载时创建，线程安全");
        System.out.println("6. 可以用于 switch 语句");
    }

    /**
     * 处理颜色的方法，演示枚举在 switch 中的使用
     */
    private static void processColor(Color color) {
        switch (color) {
            case RED:
                System.out.println("处理红色");
                break;
            case GREEN:
                System.out.println("处理绿色");
                break;
            case BLUE:
                System.out.println("处理蓝色");
                break;
            default:
                System.out.println("未知颜色");
        }
    }

    /**
     * 演示注解
     * 面试题：Java 注解有什么用？常见的注解有哪些？
     */
    private static void demonstrateAnnotation() {
        System.out.println("\n23. === 注解演示 ===");
        
        // 使用注解的类
        AnnotationDemo demo = new AnnotationDemo();
        
        // 通过反射获取注解信息
        Class<?> clazz = demo.getClass();
        
        // 类级别注解
        if (clazz.isAnnotationPresent(MyClassAnnotation.class)) {
            MyClassAnnotation classAnnotation = clazz.getAnnotation(MyClassAnnotation.class);
            System.out.println("类注解 - 作者: " + classAnnotation.author() + 
                             ", 版本: " + classAnnotation.version());
        }
        
        // 方法级别注解
        try {
            java.lang.reflect.Method method = clazz.getMethod("annotatedMethod", String.class);
            if (method.isAnnotationPresent(MyMethodAnnotation.class)) {
                MyMethodAnnotation methodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
                System.out.println("方法注解 - 描述: " + methodAnnotation.description());
            }
            
            // 参数注解
            java.lang.annotation.Annotation[][] paramAnnotations = method.getParameterAnnotations();
            for (int i = 0; i < paramAnnotations.length; i++) {
                for (java.lang.annotation.Annotation annotation : paramAnnotations[i]) {
                    if (annotation instanceof MyParameterAnnotation) {
                        MyParameterAnnotation paramAnnotation = (MyParameterAnnotation) annotation;
                        System.out.println("参数 " + i + " 注解 - 名称: " + paramAnnotation.name());
                    }
                }
            }
        } catch (NoSuchMethodException e) {
            System.out.println("方法不存在: " + e.getMessage());
        }
        
        // 字段注解
        try {
            java.lang.reflect.Field field = clazz.getDeclaredField("annotatedField");
            if (field.isAnnotationPresent(MyFieldAnnotation.class)) {
                MyFieldAnnotation fieldAnnotation = field.getAnnotation(MyFieldAnnotation.class);
                System.out.println("字段注解 - 必需: " + fieldAnnotation.required() + 
                                 ", 默认值: " + fieldAnnotation.defaultValue());
            }
        } catch (NoSuchFieldException e) {
            System.out.println("字段不存在: " + e.getMessage());
        }
        
        System.out.println("\n常见注解:");
        System.out.println("1. @Override - 方法重写");
        System.out.println("2. @Deprecated - 已过时");
        System.out.println("3. @SuppressWarnings - 抑制警告");
        System.out.println("4. @FunctionalInterface - 函数式接口");
        System.out.println("5. @Target - 注解目标");
        System.out.println("6. @Retention - 注解保留策略");
        System.out.println("7. @Documented - 文档化");
        System.out.println("8. @Inherited - 可继承");
        
        System.out.println("\n注解的作用:");
        System.out.println("1. 提供信息给编译器");
        System.out.println("2. 编译时和部署时处理");
        System.out.println("3. 运行时处理");
        System.out.println("4. 代码分析工具");
        System.out.println("5. 框架配置 (Spring、Hibernate 等)");
    }
}

// ========== 辅助类定义 ==========

/**
 * 动物抽象类 - 演示继承和多态
 */
abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 封装：提供getter方法
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    // 普通方法
    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
    
    // 具体方法
    public void sleep() {
        System.out.println(name + " 正在睡觉");
    }
    
    // 抽象方法 - 子类必须实现
    public abstract void makeSound();
}

/**
 * 狗类 - 继承Animal
 */
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 汪汪叫");
    }
    
    public void bark() {
        System.out.println(name + " 在狂吠");
    }
}

/**
 * 猫类 - 继承Animal
 */
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 喵喵叫");
    }
}

/**
 * 飞行接口 - 演示抽象
 * 演示接口特点：只能有抽象方法和常量
 */
interface Flyable {
    // 常量 (public static final)
    int MAX_ALTITUDE = 10000;
    
    // 抽象方法 (public abstract)
    void fly();
}

/**
 * 鸟类 - 实现接口
 */
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在天空中飞翔，最大高度: " + MAX_ALTITUDE + " 米");
    }
}

/**
 * 访问修饰符演示类
 */
class AccessModifierDemo {
    public String publicVar = "public变量";
    protected String protectedVar = "protected变量";
    String packageVar = "package变量";
    private String privateVar = "private变量";
    
    public void showAccessibility() {
        System.out.println("类内部可以访问所有变量:");
        System.out.println(publicVar);
        System.out.println(protectedVar);
        System.out.println(packageVar);
        System.out.println(privateVar);
    }
}

/**
 * 父类 - 演示this和super
 */
class Parent {
    protected String name = "父类";
    
    public Parent(String name) {
        this.name = name;
        System.out.println("父类构造器: " + name);
    }
    
    public void show() {
        System.out.println("父类方法");
    }
}

/**
 * 子类 - 演示this和super
 */
class Child extends Parent {
    private String name = "子类";
    
    public Child(String name) {
        super("父类-" + name); // 调用父类构造器
        this.name = name; // this指向当前对象
        System.out.println("子类构造器: " + name);
    }
    
    public void showDifference() {
        System.out.println("this.name: " + this.name); // 子类属性
        System.out.println("super.name: " + super.name); // 父类属性
        
        this.show(); // 调用当前类方法
        super.show(); // 调用父类方法
    }
    
    @Override
    public void show() {
        System.out.println("子类重写方法");
    }
}

/**
 * 静态演示类
 */
class StaticDemo {
    private static int count = 0;
    
    public static void staticMethod() {
        count++;
        System.out.println("静态方法调用次数: " + count);
        // System.out.println(this.instanceVar); // 编译错误，静态方法不能访问实例变量
    }
}

/**
 * 重载演示类
 */
class OverloadDemo {
    public void print(String str) {
        System.out.println("打印字符串: " + str);
    }
    
    public void print(int num) {
        System.out.println("打印整数: " + num);
    }
    
    public void print(String str, int num) {
        System.out.println("打印字符串和整数: " + str + ", " + num);
    }
}

/**
 * 人员类 - 演示equals和hashCode
 */
class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Person person = (Person) obj;
        return age == person.age && 
               (name != null ? name.equals(person.name) : person.name == null);
    }
    
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    
    // Getter方法
    public String getName() { return name; }
    public int getAge() { return age; }
}

/**
  * 反射演示类
  */
 class ReflectionDemo {
     private String privateField;
     
     public ReflectionDemo(String value) {
         this.privateField = value;
     }
     
     public String getPrivateField() {
         return privateField;
     }
 }



// ==================== 抽象类和接口演示 ====================



/**
 * 游泳接口
 */
interface Swimmable {
    void swim();
}

/**
 * 鱼类 - 实现游泳接口
 */
class Fish implements Swimmable {
    @Override
    public void swim() {
        System.out.println("鱼儿在水中游泳");
    }
}

/**
 * 鸭子类 - 多接口实现
 * 演示一个类可以实现多个接口
 */
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子在低空飞行");
    }
    
    @Override
    public void swim() {
        System.out.println("鸭子在水面游泳");
    }
    
    public void walk() {
        System.out.println("鸭子在陆地行走");
    }
}

// ==================== 内部类演示 ====================

/**
 * 外部类 - 演示各种内部类
 */
class OuterClass {
    private String outerField = "外部类字段";
    private static String staticOuterField = "外部类静态字段";
    
    /**
     * 成员内部类
     * 特点：可以访问外部类的所有成员（包括私有成员）
     */
    public class InnerClass {
        private String innerField = "内部类字段";
        
        public void innerMethod() {
            System.out.println("成员内部类访问外部类字段: " + outerField);
            System.out.println("成员内部类访问静态字段: " + staticOuterField);
            System.out.println("内部类自己的字段: " + innerField);
        }
    }
    
    /**
     * 静态内部类
     * 特点：只能访问外部类的静态成员
     */
    public static class StaticInnerClass {
        private String staticInnerField = "静态内部类字段";
        
        public void staticInnerMethod() {
            System.out.println("静态内部类访问外部类静态字段: " + staticOuterField);
            // System.out.println(outerField); // 编译错误：不能访问非静态成员
            System.out.println("静态内部类自己的字段: " + staticInnerField);
        }
    }
    
    /**
     * 包含局部内部类的方法
     */
    public void methodWithLocalClass() {
        final String localVariable = "局部变量";
        
        /**
         * 局部内部类
         * 特点：定义在方法中，可以访问 final 或 effectively final 的局部变量
         */
        class LocalInnerClass {
            public void localInnerMethod() {
                System.out.println("局部内部类访问外部类字段: " + outerField);
                System.out.println("局部内部类访问局部变量: " + localVariable);
            }
        }
        
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.localInnerMethod();
    }
}

// ==================== 泛型演示 ====================

/**
 * 泛型类
 * 演示泛型类的定义和使用
 */
class GenericClass<T> {
    private T value;
    
    public GenericClass(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

/**
 * 泛型方法演示类
 */
class GenericMethods {
    
    /**
     * 泛型方法 - 交换数组中两个元素的位置
     */
    public static <T> void swap(T[] array, int i, int j) {
        if (i >= 0 && i < array.length && j >= 0 && j < array.length) {
            T temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    
    /**
     * 通配符 ? extends - 上界通配符
     * 只能读取，不能写入（除了 null）
     */
    public static void printList(List<? extends Object> list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
    
    /**
     * 通配符 ? super - 下界通配符
     * 可以写入，读取时只能当作 Object
     */
    public static void addNumbers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
        // Integer num = list.get(0); // 编译错误
        Object obj = list.get(0); // 只能当作 Object
    }
}

// ==================== 枚举演示 ====================

/**
 * 简单枚举 - 颜色
 */
enum Color {
    RED, GREEN, BLUE
}

/**
 * 带属性和方法的枚举 - 行星
 */
enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6),
    MARS(6.421e+23, 3.3972e6),
    JUPITER(1.9e+27, 7.1492e7),
    SATURN(5.688e+26, 6.0268e7),
    URANUS(8.686e+25, 2.5559e7),
    NEPTUNE(1.024e+26, 2.4746e7);
    
    private final double mass;   // 质量 (kg)
    private final double radius; // 半径 (m)
    
    // 万有引力常数 (m³ kg⁻¹ s⁻²)
    private static final double G = 6.67300E-11;
    
    // 构造方法
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    
    // 访问器方法
    public double getMass() { return mass; }
    public double getRadius() { return radius; }
    
    // 计算表面重力
    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    
    // 计算物体在该行星表面的重量
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

// ==================== 注解演示 ====================

/**
 * 类级别注解
 */
@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE)
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@interface MyClassAnnotation {
    String author() default "Unknown";
    String version() default "1.0";
}

/**
 * 方法级别注解
 */
@java.lang.annotation.Target(java.lang.annotation.ElementType.METHOD)
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@interface MyMethodAnnotation {
    String description() default "";
}

/**
 * 字段级别注解
 */
@java.lang.annotation.Target(java.lang.annotation.ElementType.FIELD)
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@interface MyFieldAnnotation {
    boolean required() default false;
    String defaultValue() default "";
}

/**
 * 参数级别注解
 */
@java.lang.annotation.Target(java.lang.annotation.ElementType.PARAMETER)
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@interface MyParameterAnnotation {
    String name() default "";
}

/**
 * 使用注解的演示类
 */
@MyClassAnnotation(author = "张三", version = "2.0")
class AnnotationDemo {
    
    @MyFieldAnnotation(required = true, defaultValue = "默认值")
    private String annotatedField;
    
    @MyMethodAnnotation(description = "这是一个带注解的方法")
    public void annotatedMethod(@MyParameterAnnotation(name = "输入参数") String param) {
        System.out.println("带注解的方法被调用，参数: " + param);
    }
}

// ==================== Java 8 接口演示 ====================

/**
 * Java 8 接口特性演示
 * 支持默认方法和静态方法
 */
interface Java8Interface {
    
    // 抽象方法
    void abstractMethod();
    
    // 默认方法 (Java 8+)
    default void defaultMethod() {
        System.out.println("这是接口的默认方法");
    }
    
    // 静态方法 (Java 8+)
    static void staticMethod() {
        System.out.println("这是接口的静态方法");
    }
}

/**
 * Java 8 接口实现类
 */
class Java8InterfaceImpl implements Java8Interface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }
    
    // 可以选择重写默认方法
    @Override
    public void defaultMethod() {
        System.out.println("重写了接口的默认方法");
    }
}